BCI NET/BCI NET Dec 94.iso/archives/programming/c/sas-c-emacs-b3.lha/slashquote/slashquote.c

C/C++ Source or Header | 1994-03-20 | 4.8 KB | 206 lines

/*
 *  FILE
 *    slashquote.c
 *
 *  DESCRIPTION
 *    A one function ARexx function library.
 *
 *  AUTHOR
 *    Anders Lindgren, [e-mail]
 *
 *  STATUS
 *    slashquote is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published
 *    by the Free Software Foundation; either version 1, or (at your
 *    option) any later version.
 *
 *    GNU Emacs is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public
 *    License along with GNU Emacs; see the file COPYING.  If not,
 *    write to the Free Software Foundation, 675 Mass Ave, Cambridge,
 *    MA 02139, USA.
 */

/* Arguments:
 * Up to 15 arguments may be passed in the rm_Args[] array of the parameter
 * block.  Arguments are ALWAYS passed as argstrings and can generally be
 * treated like string pointers in a 'C' program.  The called function may
 * need to convert the strings to numeric values if arithmetic operations
 * are to be performed.  A NULL value in the argument slot means that the
 * argument was omitted from the function call, as in MyFunc(1,,3).
 *
 * The total number of arguments (including the defaulted ones) is available
 * in the low-order byte of the action code field rm_Action.
 * Note that REXX supports function calls with varying numbers of arguments,
 * and that the called function can always determine how many were actually
 * passed.
 *
 * Error reporting:
 * The function must return an integer error code and a result string if no
 * errors were detected.  Errors are considered to be ARexx internal error
 * codes, so the function should make use of these values as appropriate.
 * A code of 0 is interpreted to mean that everything worked.
 *
 * Result strings:
 * The result string must be returned as an argstring, a pointer to the
 * string buffer of an RexxArg structure.  Argstrings can be created by a
 * call to the ARexx Systems library function CreateArgstring().
 * N.B. Never allocate a result string if the error code is non-zero!
 */

#include <exec/types.h>

#include <exec/memory.h>

#include <rexx/storage.h>
#include <rexx/rxslib.h>
#include <rexx/errors.h>

#include <proto/exec.h>
#include <proto/rexxsyslib.h>

#include <string.h>
#include <dos.h>


/*
 *  Forward references.
 */

extern long slashquote (struct RexxMsg *, UBYTE * *);


/*
 *  Global data.
 */

struct Library * RexxSysBase;


/*
 *  FUNCTION
 *    __UserLibInit
 *
 *  DESCRIPTION
 *    Open the rexx system library.
 */

int __saveds
__UserLibInit(void)
{
    if (RexxSysBase = OpenLibrary("rexxsyslib.library", 0)) {
    return(0);
    }
    return(1);
}


/*
 *  FUNCTION
 *    __UserLibCleanup
 *
 *  DESCRIPTION
 *    Close the Rexx system library
 */

void __saveds
__UserLibCleanup(void)
{
    if (RexxSysBase) {
    CloseLibrary(RexxSysBase);
    }
}


/*
 *  FUNCTION
 *    LIBRexxEntry
 *
 *  DESCRIPTION
 *    The library entry point.
 *    Check if this library contains the desired function, otherwise
 *    return a errorcode 1.
 */

long __asm __saveds
LIBRexxEntry(register __a0 struct RexxMsg * rmptr)
{
    long        retcode = 1L;    /* Fail by default */
    UBYTE *     retval  = NULL;


    if (strcmp("SLASHQUOTE", rmptr->rm_Args[0]) == 0) {
    retcode = slashquote(rmptr, & retval);
    }
    /* Set the return values */
    __builtin_putreg(REG_A0, (long)retval);    /* Return String    */
    return(retcode);
}


/*
 *  FUNCTION
 *    slashquote
 *
 *  DESCRIPTION
 *    Manipulates a string in the following way:
 *      1) Put quotes around it.
 *      2) Escape all quotes and escapecharacters in the string. The
 *         escapecharacter is the 2:nd arg, or '\' if none is supplied.
 */

long
slashquote(struct RexxMsg * rmptr, UBYTE * * retvalp)
{
    register char    ch;
         char    qch;    /* Character to take care of. */
    register UBYTE * dest;
    register UBYTE * src;
    register long    sindex = 0;
    register long    dindex = 0;
    register int     len;

    /* Check the number of arguments */
    if ( (rmptr->rm_Action & 0xFF) == 1 ) {
    qch = '\\';    /* Default, quote backslash */
    }
    else if ( (rmptr->rm_Action & 0xFF) == 2 ) {
    qch = rmptr->rm_Args[2][0];
    }
    else {
    return(ERR10_017);
    }

    len = LengthArgstring(rmptr->rm_Args[1]);

    if (dest = AllocMem((len<<1) + 2, MEMF_CLEAR)) {

    dest[dindex++] = '"';    /* Start quote */

    src = rmptr->rm_Args[1];

    do {
        ch = src[sindex++];

        if (ch == '"' || ch == qch ) {
        dest[dindex++] = qch;
        }
        dest[dindex++] = ch;
    } while (ch);

    dest[dindex-1] = '"';    /* End quote */

    (* retvalp) = CreateArgstring(dest, dindex);

    FreeMem(dest, (len<<1) + 2);

        /* ERR10_003 "Out of memory" */
    return( (* retvalp) ? 0L : ERR10_003 );
    }
    return(ERR10_003);
}